# 字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。
# 原始字符串var1 var2
var1 = 'Hello World'
var2 = "Python Runoob!"
print("字符串var1：", var1)
print("字符串var2：", var2)
print()

# 访问字符串中的值
print("截取第一个字符串 var1[0] ：", var1[0])
print("截取下标从1开始到下标4的字符串 var2[1:5] ：", var2[1:5])

# 字符串连接
print("var1和var2字符串连接", var1, ",", var2)

# #转义字符
# 在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表:
# 转义字符	    描述
# \(在行尾时)	续行符
# \\	        反斜杠符号
# \'	        单引号
# \"	        双引号
# \a	        响铃
# \b	        退格(Backspace)
# \e	        转义
# \000	        空
# \n	        换行
# \v	        纵向制表符
# \t	        横向制表符
# \r	        回车
# \f	        换页
# \oyy	        八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
# \xyy	        十六进制数，以 \x 开头，yy代表的字符，例如：\x0a代表换行
# \other	    其它的字符以普通格式输出

# #字符串运算符
# 操作符	描述	    实例
# +	            字符串连接
# *	            重复输出字符串
# []	        通过索引获取字符串中字符
# [ : ]	        截取字符串中的一部分
# in	        成员运算符 - 如果字符串中包含给定的字符返回 True
# not in	    成员运算符 - 如果字符串中不包含给定的字符返回 True
# r/R	        原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
# %	            格式字符串
print("var1和var2相加 var1 + var2 ：", var1 + var2)
print("var1连续输出两遍 var1*2 ：", var1*2)
print("截取第一个字符串 var1[0] ：", var1[0])
print("截取下标从1开始到下标4的字符串 var2[1:5] ：", var2[1:5])
print("判断‘s’是否在“var1”中，结果是：", "s" in var1)
print("r/R将转移字符串变成原始字符串：", r'\n')
print("r/R将转移字符串变成原始字符串：", R'\n')

# # 字符串格式化
# Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
# 和c中的printf()函数用法一样

# python 字符串格式化符号
# 符号	 描述
# %c	 格式化字符及其ASCII码
# %s	 格式化字符串
# %d	 格式化整数
# %u	 格式化无符号整型
# %o	 格式化无符号八进制数
# %x	 格式化无符号十六进制数
# %X	 格式化无符号十六进制数（大写）
# %f	 格式化浮点数字，可指定小数点后的精度
# %e	 用科学计数法格式化浮点数
# %E	 作用同%e，用科学计数法格式化浮点数
# %g	 %f和%e的简写
# %G	 %F 和 %E 的简写
# %p	 用十六进制数格式化变量的地址

# 格式化操作符辅助指令:
# 符号	    功能
# *	        定义宽度或者小数点精度
# -	        用做左对齐
# +	        在正数前面显示加号( + )
# <sp>	    在正数前面显示空格
# #	        在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
# 0	        显示的数字前面填充'0'而不是默认的空格
# %	        '%%'输出一个单一的'%'
# (var)	    映射变量(字典参数)
# m.n.	    m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
# Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
print("字符串格式化（具体看代码）：""My name is %s and weight is %d kg!" % ('Tom', 21))

# # 三引号
# 三引号可以将复杂的字符串进行赋值。
# 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
# 三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
html = '''
    <HTML>
        <HEAD>
            <TITLE>Friends CGI Demo</TITLE>
        </HEAD>
        <BODY>
            <H3>ERROR</H3>
            <B>%s</B>
            <FORM>
                <INPUT TYPE=button VALUE=Back ONCLICK="window.history.back()">
            </FORM>
        </BODY>
    </HTML>
'''

sql = """
    CREATE TABLE users (  
    id INTEGER, 
    username VARCHAR(8),
    password VARCHAR(16))
"""

# # Unicode 字符串
unicode = u"hello, 你好 , world!"
print("普通字符：", unicode)
# 被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）
unicode = u'Hello\u0020World !'
print("unicode编码（中间的空格是unicode，具体看代码）：", unicode)

# # python的字符串内建函数
# 方法
# 描述
# string.capitalize()
#
# 把字符串的第一个字符大写
var = var1.capitalize()
print("把字符串的第一个字符大写（其他字符串是大写也会转成小写）.")
print(f"把 {var1} 的第一个字符大写：", var)
print()
# string.center(width)
#
# 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
var = var1.center(30)
print("返回一个原字符串居中,并默认使用空格填充至长度 width 的新字符串.")
print(f"返回 {var1} 字符串居中,使用空格填充至长度 30 的新字符串：", f'***{var}***')
var = var1.center(40, "-")
# f-string 是字符串格式化的新用法 python3.6引入
print(f"返回 {var1} 字符串居中,并使用“-”填充至长度 40 的新字符串：", f'***{var}***')
print()

# string.count(str, beg=0, end=len(string))
#
# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
var = var1.count("o", 0, 6)
print("返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数.")
print(f"在 {var1} 里面，0 到 6 范围内 o 出现的次数：", var)
var = var1.count("o")
print(f"返回 o 在 {var1} 里面出现的次数：", var)
print()
# string.encode(encoding='UTF-8', errors='strict')
#
# 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
var = var1.encode(encoding='UTF-8', errors='strict')
print("以 encoding='UTF-8' 指定的编码格式编码：", var)

# string.decode(encoding='UTF-8', errors='strict')
#
# 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace'
var = var.decode(encoding='UTF-8', errors='strict')
print("以 encoding='UTF-8' 指定的编码格式编码：", var)
print()
# string.endswith(obj, beg=0, end=len(string))
#
# 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
var = var1.endswith("O", 0, 5)
print("检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.")
print(f"检查字符串 {var1} 的0到5是否以 o 结束返回的是：", var)

# string.expandtabs(tabsize=8)
#
# 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
var = var1.expandtabs(5)
print("把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8")
print(f"把字符串 {var1} 中的 tab 符号转为空格：", var)
print()
# string.find(str, beg=0, end=len(string))
#
# 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
var = var1.find("s", 0, len(var1))
print("检测 str 是否包含在 string 中（区分大小写，多个则返回字符第一次出现的位置），如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1")
print(f"检测 s 是否包含在 {var1} 中 的 0 到 len(var1)范围内：", var)
var = var1.find("W", 0, 8)
print(f"检测 w 是否包含在 {var1} 中 的 0 到 8范围内：", var)
var = var1.find("l", 0, 8)
print(f"检测 l 是否包含在 {var1} 中 的 0 到 8范围内（两个 l ，返回第一个l的位置）：", var)

# string.format()
#
# 格式化字符串
var = var1.format()
print("格式化字符串：", var)

# string.isalnum()
#
# 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
var = var1.isalnum()
print("如果 string 至少有一个字符并且所有字符都是字母或数字则返")
print(f"{var1} 是否是纯字母或数字：", var)
var3 = "asfsfd"
var = var3.isalnum()
print("asfsfd 是否是纯字母或数字：", var)
print()

# string.isalpha()
#
# 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
var = var1.isalpha()
print("如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False")
print(f"{var1} 至少有一个字符并且所有字符都是字母：", var)
var3 = "asfsfd"
var = var3.isalpha()
print(f"{var3} 至少有一个字符并且所有字符都是字母：", var)
print()

# string.isdecimal()
#
# 如果 string 只包含十进制数字则返回 True 否则返回 False.
var = var1.isdecimal()
print("如果 string 只包含十进制数字则返回 True 否则返回 False.")
print(f"{var1} 只包含十进制数：", var)
var3 = "214214321"
var = var3.isalpha()
print(f"{var3} 只包含十进制数：", var)
print()

# string.isdigit()
#
# 如果 string 只包含数字则返回 True 否则返回 False.
var = var1.isdigit()
print("如果 string 只包含数字则返回 True 否则返回 False.")
print(f"{var1} 只包含数字：", var)
var3 = "214214321"
var = var3.isdigit()
print(f"{var3} 只包含数字：", var)
print()

# string.isnumeric()
#
# 如果 string 中只包含数字字符，则返回 True，否则返回 False
var = var1.isnumeric()
print("如果 string 中只包含数字字符，则返回 True，否则返回 False.")
print(f"{var1} 只包含数字字符：", var)
var3 = "13412"
var = var3.isnumeric()
print(f"{var3} 只包含数字字符：", var)
print()

# string.isspace()
#
# 如果 string 中只包含空格，则返回 True，否则返回 False.
var = var1.isspace()
print("# 如果 string 中只包含空格，则返回 True，否则返回 False.")
print(f"{var1} 中只包含空格：", var)
var3 = " "
var = var3.isspace()
print(f"{var3} 中只包含空格：", var)
print()

# string.islower()
#
# 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
var = var1.islower()
print("如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False.")
print(f"{var1} 包含至少一个区分大小写的字符：", var)
var3 = "asfsasf"
var = var3.islower()
print(f"{var3} 包含至少一个区分大小写的字符：", var)
print()

# string.isupper()
#
# 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
var = var1.isupper()
print("如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False.")
print(f"{var1} 中包含至少一个区分大小写的字符：", var)
var3 = "WFWFW"
var = var3.isupper()
print(f"{var3} 中包含至少一个区分大小写的字符：", var)
print()

# string.join(seq)
#
# 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
var = ",".join(var1)
print("以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串")
print(f"{var1} 以 “，” 作为分隔符，将所有的元素合并为一个新的字符串：", var)
print()

# string.ljust(width)
#
# 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
var = var1.ljust(30)
print("返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串")
print(f"{var1} 以 “，” 字符串左对齐,并使用空格填充至长度 width 的新字符串：", var)
print()

# string.rjust(width)
#
# 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
var = var1.rjust(30)
print("返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串")
print(f"{var1} 以 “，” 字符串右对齐,并使用空格填充至长度 width 的新字符串：", var)
print()


# string.lower()
#
# 转换 string 中所有大写字符为小写.
var = var1.lower()
print("转换 string 中所有大写字符为小写.")
print(f"{var1} 所有大写字符为小写：", var)
print()

# string.upper()
#
# 转换 string 中的小写字母为大写
var = var1.upper()
print("转换 string 中的小写字母为大写")
print(f"{var1} 所有大写字符为大写：", var)
print()

# string.strip([obj])
#
# 在 string 上执行 lstrip()和 rstrip()
var = var1.strip()
print("在 string 上执行 lstrip()和 rstrip()")
print(f"{var1} 截掉所有空格：", var)
print()

# string.lstrip()
#
# 截掉 string 左边的空格
var = var1.lstrip()
print("截掉 string 左边的空格")
print(f"{var1} 截掉左边的空格：", var)
print()

# string.rstrip()
#
# 删除 string 字符串末尾的空格.
var = var1.rstrip()
print("截掉 string 右边的空格")
print(f"{var1} 截掉右边的空格：", var)
print()

# max(str)
#
# 返回字符串 str 中最大的字母。
var = max(var1)
print("返回字符串 str 中最大的字母。")
print(f"{var1} 中最大的字母是：", var)
print()

# min(str)
#
# 返回字符串 str 中最小的字母。
var = min(var1)
print(f"{var1} 中最小的字母是：", var)

# string.partition(str)
#
# 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
web_site = "http://www.w3cschool.cc/"
var = web_site.partition("http://")
print("有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.")
print(f"{web_site} 字 符 串 分 成 一 个 3 元 素 的 元 组：", var)
print()

# string.rpartition(str)
#
# 类似于 partition()函数,不过是从右边开始查找


# string.replace(str1, str2,  num=string.count(str1))
#
# 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
var = var1.replace("l", "L")
print("把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.")
print(f"{var1} 中 的 l 替换成 L：", var)
print()

# string.rfind(str, beg=0,end=len(string) )
#
# 类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
var = var1.rfind("l")
print("类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。")
print(f"{var1}中l最后一次出现的位置：", var)
print()

# string.index(str, beg=0, end=len(string))
#
# 跟find()方法一样，只不过如果str不在 string中会报一个异常.
var = var1.index("W")
print("跟find()方法一样，只不过如果str不在 string中会报一个异常.")
print(f"返回 W 在 {var1} 中出现的位置：", var)
print()

# string.rindex( str, beg=0,end=len(string))
#
# 类似于 index()，不过是从右边开始.
var = var1.rindex("l")
print("类似于 index()，不过是从右边开始")
print(f"返回 l 在 {var1} 中最后一次出现的位置：", var)
print()

# string.split(str="", num=string.count(str))
#
# 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
var = var1.split("l")
print("以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串")
print(f"{var1}以 l 为分隔符分割成列表", var)
print()

# string.splitlines([keepends])
#
# 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
varlines = "asdfa\r asfsa \r\n asdfsa \n arsafsad"
var = varlines.splitlines()
print("按照行('\\r', '\\r\\n', \\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。")
print(f"{varlines}以 换行 为分隔符分割成列表", var)
print()

# string.maketrans(intab, outtab])
#
# maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
intab = "abcde"
outtab = "12345"
trantab = str.maketrans(intab, outtab)
str = "abcde"
print("maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。")
print(str.translate(trantab))
print()

# string.translate(str, del="")
#
# 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
d = {'a': '1', 'b': '2', 'c': '3', 'd': '4', 'e': '5'}
trantab = str.maketrans(d)
st='abcde'
print("根据 str 给出的表(包含 256 个字符)转换 string 的字符")
print(st.translate(trantab))
print()

# string.startswith(obj, beg=0,end=len(string))
#
# 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
var = var1.startswith("l")
print("检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.")
print(f"{var1}是否是以　H 开头：", var)
print()

# string.swapcase()
#
# 翻转 string 中的大小写
var = var1.swapcase()
print("翻转 string 中的大小写")
print(f"{var1} 翻转大小写", var)
print()


# string.istitle()
#
# 如果 string 是标题化的(见 title())则返回 True，否则返回 False
var = var1.istitle()
print("# 如果 string 是标题化的(见 title())则返回 True，否则返回 False")
print(f"{var1} 是标题化的：", var)
var3 = " aaa爱上飞洒发WF..G"
var = var3.isspace()
print(f"{var3} 是标题化的：", var)
print()

# string.title()
#
# 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
var = var1.title()
print("返回'标题化'的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())")
print(f"{var1} 标题化：", var)
print()

# string.zfill(width)
#
# 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
var = var1.zfill(30)
print("返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0")
print(f"设置{var1}总长度，不足的补0：", var)
